Java

您所在的位置：网站首页 › 接口抽象类区别 Java › Java

Java

2024-07-13 03:31| 来源: 网络整理| 查看: 265

接口与抽象类相比，使用率是最高的，所有的设计基本是围绕接口进行的，这部分内容很重要，要彻底学明白需要很长时间，与接口相关的两个重要设计模式：工厂设计模式、代理设计模式，是需要死记硬背的。

1、接口的基本概念

接口是一种特殊类，但是接口中的组成比类的简单，主要由抽象方法和全局常量组成。而接口使用interface关键字来定义。

【举例】：定义一个接口

代码语言：javascript复制interface A{ //定义了一个接口 public static final String MSG= "hello"; public abstract void print(); }

接口是不能直接实例化对象的，当一个接口定义完成后，按如下步骤进行接口的使用：

1）接口一定要定义子类，子类利用implements关键字来实现接口，一个子类可以实现多个接口；

--秒杀抽象类的单继承局限；

2）接口的子类必须覆写接口中的全部抽象方法；3）接口的对象利用子类对象的向上转型进行实例化操作。

【举例】：使用接口

代码语言：javascript复制public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); X x = new X();//实例化子类对象 A a = x; //子类为父接口实例化 B b = x; a.print(); b.fun(); } } interface A{ //定义了一个接口 public static final String MSG= "hello"; public abstract void print(); } interface B{ public abstract void fun(); } class X implements A,B{//同时实现A、B两个父接口 @Override public void print() { //覆写接口A中的抽象方法 System.out.println("你好，接口A"); } @Override public void fun() {//覆写接口B中的抽象方法 System.out.println(MSG); } }

但是，现在有这样一种操作，也能输出hello，B和A没有什么关系，却可以转换，因为X是子类。

【注意】：关于接口的组成描述

接口里面在定义的时候就已经明确的给出了开发要求：抽象方法和全局常量，所以，以下两种接口的定义本质上是一样的。

完整定义

简化定义

interface A{ //定义了一个接口 public static final String MSG= "hello"; public abstract void print(); }

interface A{ //定义了一个接口 String MSG= "hello"; void print(); }

如果定义接口方法时没有使用public，本质上也不是default权限，默认就是public。为了防止开发者概念混淆，所以后续开发建议在定义接口时都写上public，可以不写abstract。

代码语言：javascript复制interface A{ //定义了一个接口 String MSG= "hello"; public void print(); }

现在程序中出现有类、抽象类、接口，三者之间的联系需要注意：

一个普通类若要实现接口，又要继承抽象类，一定要显extends继承抽象类，再实现接口，形式如下：

class 子类 extends 抽象类 implements 接口1,接口2,...{}

【举例】：观察子类的多继承

代码语言：javascript复制interface A{ //定义了一个接口 public static final String MSG= "hello"; public abstract void print(); } abstract class B{ public abstract void fun(); } class X extends B implements A{ @Override public void print() { } @Override public void fun() { } }

另外，除了以上的结构外，抽象类还可以直接实现接口：

【举例】：抽象类实现接口

代码语言：javascript复制interface A{ //定义了一个接口 public static final String MSG= "hello"; public abstract void print(); } abstract class B implements A{ //此时抽象类有两个抽象方法 public abstract void fun(); } class X extends B{ @Override public void print() { } @Override public void fun() { } }

抽象类可以实现接口，但是反过来，接口是不能继承抽象类的，一个接口却可以使用extends关键字继承多个父接口。

【举例】：接口多继承

代码语言：javascript复制interface A{ //定义了一个接口 public void printA(); } interface B{ public void printB(); } interface C extends A,B{ //C是A与B 的子接口 public void printC(); } class X implements C{ @Override public void printA() { } @Override public void printB() { } @Override public void printC() { } }

虽然接口本身只能有抽象方法和全局常量，但是内部的结构是不受限制的，也就是一个接口的内部可以继续定义内部类，内部抽象类，或内部接口。如果一个内部接口上使用了static定义，这个内部接口就属于外部接口。

【举例】：使用static定义内部接口

代码语言：javascript复制interface A{ //定义了一个接口 static interface B{ public void print(); } } class X implements A.B{//注意此处使用的是......... @Override public void print() { } }

对于接口的使用，有如下几点总结：

接口避免了单继承局限，一个子类可以实现多个接口；接口中的权限统一为public，方法都是抽象方法，大多数情况下接口中都不会定义全局常量；所有的内部类结构都不受定义语法的限制，static定义的内部接口就是外部接口。

实际开发中，接口的三个使用原则：

制定操作的标准；表示一种能力；将服务器端的远程方法视图提供给客户端。2、接口的应用——定义标准

现实生活中，对于接口的名字很常见，如USB接口、HDMI接口、DVI接口等。以USB设备为主，描述一下接口的实际作用：

【举例】：首先要定义的就是接口

代码语言：javascript复制interface USB{ public void start(); public void stop(); }

【举例】：电脑上提供有支持USB的操作插入点

代码语言：javascript复制class Computer{ public void plugin(USB usb){ usb.start(); usb.stop(); } }

不管有多少个设备，电脑plugin()方法只有接收USB的接口实例，操作步骤就是固定的。

【举例】：定义USB的子类

代码语言：javascript复制class Flash implements USB{ @Override public void start() { System.out.println("开始使用U盘进行操作"); } @Override public void stop() { System.out.println("U盘停止操作"); } } class Keyboard implements USB{ @Override public void start() { System.out.println("开始使用键盘进行操作"); } @Override public void stop() { System.out.println("键盘停止操作"); } }

【举例】：程序调用

所以，如果有了接口标准，即便有千万个子类，也是在一个接口上使用的，所以说接口可以定义标准，说的再高级一点：

接口可以连接两个不同的层。

3、接口的应用——工厂设计模式（Factory）

这部分内容很重要，以下设计的工厂类程序基本结构必须要记住。工厂模式用于对象的创建，使得客户从具体的产品对象中被解耦。首先编写一段简单的代码，观察下为什么会有所谓的工厂设计模式？

【举例】：观察程序定义

代码语言：javascript复制public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Fruit f = new Apple(); f.eat(); } } interface Fruit{ public void eat(); } class Apple implements Fruit{ @Override public void eat() { System.out.println("吃苹果"); } }

以上代码本身看上去没什么语法问题，但是有一个设计上的缺失，若现在Fruit增加了一个子类，且主类想使用这个子类，该怎么办？

代码语言：javascript复制public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Fruit f = new Cherry(); f.eat(); } } interface Fruit{ public void eat(); } class Apple implements Fruit{ @Override public void eat() { System.out.println("吃苹果"); } } class Cherry implements Fruit{ @Override public void eat() { System.out.println("吃樱桃"); } }

以上，我们发现，若要扩充我们的程序，却影响了客户端的执行，若要解决这个问题，可参照Java可移植性的实现原理：

不可移植性：程序-》操作系统；可移植性：程序-》JVM-》操作系统；

【举例】在客户端与接口之间引入一个中间层

代码语言：javascript复制public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Fruit f = Factory.getInstance("apple");//这里可以改成外部输入的 if(f!=null){ f.eat(); } } } interface Fruit{ public void eat(); } class Apple implements Fruit{ @Override public void eat() { System.out.println("吃苹果"); } } class Cherry implements Fruit{ @Override public void eat() { System.out.println("吃樱桃"); } } class Factory{ public static Fruit getInstance(String className){ //直接取得接口实例 if("apple".equals(className)){ return new Apple(); }else if("cherry".equals(className)){ return new Cherry(); }else { return null; } } }

以上代码形式，如果现在想增加一个新的子类，不需要修改客户端，直接修改工厂类Factory类即可。

4、接口的应用——代理设计模式（Proxy）

这部分内容很重要，以下设计的程序基本结构必须要记住。

代理设计模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。换种说法，代理结构指的是在接口上的一种应用，一个接口有一个核心的操作主题，但是只依靠核心的操作主题是无法完成所需要的功能的，那么需要有一个代理主题，代理主题完成所有的与核心主题有关的概念。

【举例】：代码实现（一个客户通过讨债公司讨债的故事）

代码语言：javascript复制public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Subject sub = new ProxySubject(new RealSubject()); sub.get(); } } interface Subject{ //核心操作主题 public void get();//核心操作 } class RealSubject implements Subject{ @Override public void get() { System.out.println("终于取回了被强占的Money"); } } class ProxySubject implements Subject { //代理的真实主题 private Subject subject; //代理的真实主题 public ProxySubject(Subject subject){ this.subject = subject; } public void prepare(){ System.out.println("讨债前的准备工作"); } @Override public void get() { this.prepare(); this.subject.get();//真实主题的讨债 this.destroy(); } public void destroy(){ System.out.println("讨债后的收尾工作"); } }

5、抽象类与接口的区别（常见面试题）

目前我们学习了抽象类、类、对象、接口，这些概念从开发上来讲有什么关系？

所有类的抽象使用的就是接口，接口避免了单继承的局限；

【面试题】：抽象类与接口的区别？

序号

区别

抽象类

接口

定义关键字

abstract

interface

组成

属性、常量、抽象方法、构造方法、普通方法

全局常量、抽象方法

权限

可以使用各种权限

只能是public

子类实现

extends关键继承一个抽象类

implements关键字实现多个接口

关系

抽象类可以实现多个接口

接口不能继承抽象类，但是却可以利用extends关键字实现接口的多继承

对象实例化

依靠子类对象的向上转型实现抽象类或接口对象的实例化

设计模式

模板设计模式

工厂设计模式、代理设计模式

操作局限

具有单继承局限

没有单继承局限

由以上比较，抽象类与接口实际上都可以限制子类必须要覆写的要求，但是由于抽象类本身存在单继承局限，所以日后开发中，若发现抽象类与接口都可以使用时，优先考虑接口，而抽象类通常用来作为接口与普通类之间的过渡类使用。

6、总结

1）接口利用interface关键字定义，接口中定义方法的情况居多；

2）接口利用对象向上转型实现接口对象的实例化操作，调用的方法是每个子类所覆写的方法；

3）接口的应用：标准（连接不同的两种类）、工厂设计模式、代理设计模式。

【本文地址】

公司简介

联系我们